The model was never the problem

Section 01Everyone agrees it's failing. Almost no one agrees why.

Two numbers are in every board deck right now.

Gartner expects more than 40% of agentic AI projects to be canceled by the end of 2027, on escalating costs, unclear business value, and weak risk controls. And an MIT study of 300 deployments found that roughly 95% of enterprise GenAI pilots deliver zero measurable return, against $30–40 billion spent, with only about 5% reaching production.

Read both post-mortems and the same pattern falls out. Gartner's list of causes is cost, unclear value, and risk. Model capability did not make the cut. MIT is blunter: the divide between the 5% who win and the 95% who stall is not explained by model quality.

Andrej Karpathy has been making the same point to the same audience. His line that this is "the decade of agents, not the year" was a shot at the hype, and his reason is precise: today's agents can't plan, and they can't remember, so their knowledge is pre-compiled instead of compounding. That is not a complaint about the model. It's a description of everything wrapped around it. There's even a name for that wrapper now — Ethan Mollick, Philipp Schmid, and Martin Fowler's team have all spent 2026 writing about the harness. This series takes it apart, one layer at a time.

Section 02The stack isn't the problem. The space between the tools is.

Every second builder call I take opens with the same diagram: n8n for the workflows, Replit or Bolt for the app, LangGraph for orchestration, Airbyte for the pipelines, a memory layer like Honcho on the side. Each tool is good. For a weekend prototype the stack is close to magic. Then production arrives, and the diagram turns into a bill.

Look at what you actually build to take that diagram live. The tools don't share state, so you write the glue for every pair. The memory layer doesn't know your domain, so you design the schema by hand. Nothing evaluates itself, so the evals and observability are yours. Then the permanent job starts: token optimization, caching, context pruning, routing cheap calls to cheap models.

Section 03Six cents a task is nothing — until you put it on a workload.

A stateless agent has no memory of its own work, so every call re-sends the whole ritual: system prompt, tool definitions, retrieved documents, history. Fifteen thousand tokens in and a thousand out per task is ordinary for real enterprise work. At frontier list prices near $3 per million in and $15 per million out, that's about six cents a task. On two thousand tasks a day, here's where it lands.

The first bar should bother you for its shape, not its height. On day 400 the stateless agent pays exactly what it paid on day 1 — same work run 800,000 times, nothing learned from any of it. The second bar is what happens when the system keeps an event-sourced record of what it has done and stops re-shipping context wholesale: roughly 70% fewer tokens over time. The third is the step most teams never reach, because the integration tax ate the roadmap first — fine-tune a small model on your own traces for the lanes you've already solved, and cut that bill by roughly 90%.

This is exactly what MIT found from the other side. The 5% who crossed the divide weren't the ones with the best model. They were the ones who shipped tools with memory and learning loops, and who bought from partners rather than building alone — vendor-built systems reached production about twice as often as internal builds.

Section 04A tool's cost is a flat line. A system's cost bends down.

Name what you're watching: the COGS curve. Your tokens are cost of goods sold, and over a year the only thing that matters is which way the curve points. Flat means you bought a tool. Falling means you own a system. It's a one-question audit, and it works on any platform, including ours.

Jensen Huang put the same idea more bluntly than I can. At NVIDIA's 2026 GTC, arguing that architecture is everything in the agentic era:

That's the whole thesis in eleven words. A free model on the wrong architecture still loses, because the cost that sinks you was never the model's price tag. It was the harness — or the absence of one.

Section 05The five-letter test: COGSS

Cost is only the first letter of how we grade any AI decision. The whole scorecard is COGSS.

1. CCostIs the per-task curve falling, or flat forever?
2. OOwnershipDo your traces and tuned models sit on your side?
3. GGovernanceAre rules enforced, or only requested in a prompt?
4. SScaleCan you run 100 agents without a rewrite?
5. SSovereignIs a model swap a config change, or a crisis?

Read those back and they aren't five features. They're five ways of asking one question: does the system belong to you, or are you renting a capability you don't control? Every issue in this series takes one letter and one hard problem and shows the mechanism that answers it.

Section 06What to do Monday

You don't need our platform to use any of this. Take one agent in production, plot its cost per task for the last eight weeks, and look at the slope. Flat line: you have a tool wearing the costume of a system, and no model upgrade will bend it, because the model was never the variable. Falling line: find what's bending it and do more of that. Everything in the next nine issues is a way to bend that line on purpose.